home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / Hack / UTILS / XIT20.ZIP / XIT.C < prev    next >
C/C++ Source or Header  |  1994-05-19  |  14KB  |  306 lines
  1. #include <string.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <conio.h>
  5. #include <alloc.h>
  6. #include <time.h>
  7. #include <bios.h>
  8.  
  9. #define MAX_WPWD_LEN  10
  10. #define MAX_EPWD_LEN  15
  11.  
  12. extern char *crypt(register const char *key, register const char *setting);
  13. int   ProcessPasswdFile(char *efn);
  14. void   Back2DOS(int code, char *txt);
  15. void   DisplayStatus(char *wpwd);
  16. void   help(void);
  17.  
  18. unsigned long wc  =0;       // Word counter
  19. unsigned int eacct=0;       // Number of accounts (encrypted passwords)
  20. unsigned int fpwd =0;       // Number of cracked passwords
  21. time_t tm1, tm2;            // Time counters
  22. FILE   *ofp;                // Output file pointer
  23. char   *ofn;                // Output file name
  24. char   far **dptr;          // Table of passwords
  25.  
  26.  
  27. void main(int argc, char *argv[]) {
  28.    char    wpwd[MAX_WPWD_LEN];    // Buffer for dict. words
  29.    char    epwd[MAX_EPWD_LEN];    // Buffer for encrypted passwords
  30.    char   far *ppwd;              // Current password to encrypt
  31.    char   *wfn, *efn;             // Dictionary and Passwords' filenames
  32.    FILE   *wfp, *efp;             // Dictionary and Passwords' file pointers
  33.    int    wi,   ei;               // Flags for EOF
  34.    char    fastmode;              // Flag for fastmode (1=load pwds in memory)
  35.    unsigned    more;              // fastmode=0: Flag for more passwords
  36.                                   // fastmode=1: Index for table of passwords
  37.    int    stw=0;                  // Flag for starting word
  38.    int    v=0;                    // Flag for verbose
  39.    char    stword[MAX_WPWD_LEN];  // Starting word to check in dictionary
  40.    char    salt[3]="══";          // Salt keys
  41.    long    floc;                  // File pointer offset, to adjust st.word
  42.    char   *rpwd;                  // Resulting enc.password from crypt()
  43.    char   *parm;                  // Pointer to command line options
  44.    char    ch;                    // Used by bioskey()
  45.    int    cp;                     // Parameter counter
  46.  
  47.    cputs("╔════════════════╗\r\n");
  48.    cputs("║ [XiT] v2.0 386 ║ (C) Copyright 1993, 1994  XCrypt Productions\r\n");
  49.    cputs("╚════════════════╝ by Roche'Crypt / Feb.94\r\n\n");
  50.  
  51.  
  52.    /*   ****************** PROCESS COMMAND LINE PARAMETERS ***************** */
  53.  
  54.    if(argc<4 || argc>6) help();          // Wrong number of parameters
  55.    if(argc>=5) {                         // Process command line options
  56.       cp = 4;
  57.       do {
  58.          parm = argv[cp];                // Process next parameter
  59.          if(parm[0]=='-')   parm++;      // Ignore dash charachter
  60.          switch(parm[0]) {
  61.             case 'S' :                   // STARTING WORD
  62.                _fstrcpy(stword, parm+1); // Obtain starting word
  63.                _fstrcat(stword,"\n");    // Speeds up st.word' searching process
  64.                stw=1;                    // Set flag
  65.                break;
  66.             case 'v' :                   // VERBOSE
  67.                if(!parm[1])   v = 1;
  68.                else            help();
  69.                break;
  70.             default : help();            // WRONG SWITCH
  71.          }
  72.       } while(++cp<argc);                // Go for next parameter (if any)
  73.    }
  74.  
  75.    /*   *************************** OPEN FILES **************************** */
  76.  
  77.    efn=strupr(argv[2]);
  78.    fastmode = ProcessPasswdFile(efn);   // Analyze Password file
  79.  
  80.    wfn=strupr(argv[1]);                 // Open Dictionary file
  81.    if((wfp=fopen(wfn,"r"))==NULL) {
  82.       perror(wfn); exit(-3);
  83.    }
  84.  
  85.    if(!fastmode){                        // If table is not being used
  86.       if((efp=fopen(efn,"r"))==NULL) {   // open Password file
  87.          perror(efn); exit(-3);
  88.       }
  89.    }
  90.  
  91.    ofn=strupr(argv[3]);                  // Create output file
  92.    if((ofp=fopen(ofn,"w"))==NULL) {
  93.       perror(ofn); exit(-3);
  94.    }
  95.    fclose(ofp);
  96.  
  97.    /*   ******************* GO TO SELECTED STARTING PASSWORD **************** */
  98.  
  99.    if(stw) {                           // Move file pointer to starting-word
  100.       stw=0;                           // Re-use 'stw' as a "found" flag
  101.       while(!feof(wfp) && (!stw)) {
  102.          fgets(wpwd, MAX_WPWD_LEN, wfp);
  103.          if(!strcmp(wpwd, stword))   stw++;   // Found! Exit loop
  104.       }
  105.       if(feof(wfp)) {                         // EOF was reached.
  106.          stword[strlen(stword)-1] = '\0';     // Eliminate CR character
  107.          printf("Word '%s' is not in the dictionary %s.",stword,wfn);
  108.          Back2DOS(-2,"");
  109.       }
  110.       floc = ftell(wfp) - (strlen(wpwd)+1);   // Calculate starting offset
  111.       fseek(wfp,floc,SEEK_SET);               // Readjust offset file pointer
  112.    }
  113.  
  114.    /************************************************************************/
  115.    /*                            *** MAIN  LOOP ***                           */
  116.    /************************************************************************/
  117.  
  118.    puts("Cracking... (press SPACE for status, ESC to abort)");
  119.    tm1 = time(NULL);                           // Get beginning time
  120.    wi=0;                                       // Reset EOF flag
  121.    do {
  122.       fgets(wpwd, MAX_WPWD_LEN, wfp);          // Get word in dictionary
  123.       if(!feof(wfp)) {                         // End of file not reached yet
  124.          wpwd[strlen(wpwd)-1] = '\0';          // Eliminate CR character
  125.          if(v) printf("Trying %s\n\r",wpwd);   // Echo if verbose
  126.          salt[0]=0xff;                         // Reset salt
  127.          if(fastmode) more = eacct-1;          // Start checking LAST enc.password
  128.          else          rewind(efp);            // Seek from beginning of enc.pwd file
  129.          ei=0;                                 // Reset EOF flag
  130.          wc++;                                 // Increment word counter
  131.          do {
  132.             if(fastmode)
  133.                ppwd = dptr[more];              // Assign next enc.pwd to 'ppwd'
  134.             else {
  135.                fgets(epwd, MAX_EPWD_LEN, efp); // Get encrypted password
  136.                epwd[strlen(epwd)-1] = '\0';    // Eliminate CR character
  137.                ppwd = epwd;                    // Assign next pwd to 'ppwd'
  138.                if(!feof(efp)) more=1; else more=0;
  139.             }
  140.             if(more<65535) {                   // Valid encripted password
  141.                if(salt[0]!=ppwd[0] || salt[1]!=ppwd[1]) { // Avoid encryption
  142.                   rpwd = crypt(wpwd, ppwd);  // of words that use the same salt
  143.                   salt[0]=ppwd[0];           // keys. NOTE: The enc.pwd file
  144.                   salt[1]=ppwd[1];           // must be sorted in advance!!
  145.                }
  146.                if(rpwd[2]==ppwd[2])            // Ugly coding, but much
  147.                   if(rpwd[3]==ppwd[3])         // faster than just a plain
  148.                      if(rpwd[4]==ppwd[4])      // strcmp() call. Augh!
  149.                         if(rpwd[5]==ppwd[5])
  150.                   if (!strcmp(rpwd+6,ppwd+6)) {   // PASSWORD FOUND!
  151.                      printf("'%s' deCrypts as '%s'\n",ppwd,wpwd);
  152.                      if((ofp=fopen(ofn,"a"))==NULL) { perror(ofn); exit(-3); }
  153.                      fprintf(ofp, "'%s' deCrypts as '%s'\n",ppwd,wpwd);
  154.                      fclose(ofp);
  155.                      fpwd++;
  156.                      //   ei=-1;      // Enable ONLY if you KNOW a password
  157.                                       // can't occur TWICE in the pwd file.
  158.                   }
  159.                more--;
  160.             }
  161.             else ei=-1;
  162.          } while(ei>=0);
  163.          if(bioskey(1)) {      // Check if a key has been pressed
  164.             ch=getch();
  165.             switch(ch) {
  166.                case ' ' :               // 'SPACE'
  167.                   if(v)   getch();        // When '-v' is active: PAUSE
  168.                   else                  // Otherwise: SHOW STATUS
  169.                      DisplayStatus(wpwd);
  170.                   break;
  171.                case 0x1b: Back2DOS(-1,wpwd); break;   // 'ESC'   ABORT
  172.             }
  173.          }
  174.       }
  175.       else wi=-1;
  176.    } while(wi>=0);
  177.    Back2DOS(0,"");
  178. }
  179.  
  180. int ProcessPasswdFile(char *efn) {
  181.    char   epwd[MAX_EPWD_LEN];  // Buffer for a single encrypted password
  182.    unsigned int pc=0;         // Number of accounts
  183.    char   far *tptr;            // Temporary pointer (several uses)
  184.    int   is_eof;               // Check for end of file
  185.    FILE   *efp;                  // Dictionary and Passwords file pointers
  186.  
  187.    if((efp=fopen(efn,"r"))==NULL) { perror(efn); exit(-3); }
  188.    cprintf("Counting accounts in %s...\r\n",efn);
  189.  
  190.    while(!feof(efp)) {                  // Count how many lines (passwords)
  191.       fgets(epwd, MAX_EPWD_LEN, efp);   // are in the password file
  192.       if(strlen(epwd)==14)
  193.          pc++;
  194.    }
  195.    eacct = pc;                         // Assign result to global variable
  196.    cprintf("\r\n%s contains %u passwords\r\n",efn, pc);
  197.  
  198.    // Check if there is enough memory by "trial and error"
  199.    // Sometimes farcoreleft() can screw up...
  200.    if((tptr=(char far*)farmalloc((unsigned long)MAX_EPWD_LEN*pc)) == NULL) {
  201.       // Couldn't allocate memory for all the passwords
  202.       cprintf("I don't have enough memory to load all accounts in memory.\r\n");
  203.       cprintf("I'd need %lu bytes in order to do that\r\n",(unsigned long)MAX_EPWD_LEN*pc);
  204.       cprintf("Free memory: %lu\r\n",farcoreleft());
  205.       cprintf("The slower method (XiT 1.0) will be used...\r\n");
  206.       fclose(efp);                     // Close the password file, and
  207.       return(0);                        // return (0=fastmode will NOT be used)
  208.    }
  209.    farfree(tptr);                        // Free the "trial and error" memory
  210.    if( (dptr=(char far **)farmalloc(sizeof(char far*)*pc)) == NULL) {
  211.       cputs("Weird  error #03...\r\n"); // Weird because I can't think
  212.       exit(-5);                         // this could ever happen, unless
  213.    }                                     // you're multitasking using a
  214.                                         // crappy memory manager.
  215.  
  216.    rewind(efp);                         // Go to beginning of file
  217.    cprintf("Loading accounts...\r\n");
  218.    is_eof=pc=0;                         // Set flag and counter
  219.    do {
  220.       fgets(epwd, MAX_EPWD_LEN, efp);   // Read password
  221.       if(!feof(efp)) {                  // Still data in the file
  222.          if(strlen(epwd)==14) {         // Correct password length? If so...
  223.                                         // Allocate memory for the password
  224.             if((tptr=(char far*)farmalloc(MAX_EPWD_LEN)) == NULL) {
  225.                cprintf("\r\nError allocating memory for element %d\r\n",pc);
  226.                exit(-5);
  227.             }
  228.             dptr[pc]=tptr;              // Assign indexed pointer to the buffer
  229.             epwd[strlen(epwd)-1] = '\0';// Eliminate '\n'
  230.             _fmemcpy(tptr ,epwd,15);    // Copy the password in the buffer
  231.             pc++;                       // Increment counter
  232.             if(bioskey(1)) {            // Key pressed?
  233.                if(getch()==0x1b) {      // Was it ESCAPE?
  234.                   puts("\r\nAborting!");// Then abort,
  235.                   fcloseall();          // close all files
  236.                   exit(-4);             // and exit
  237.                }
  238.             }
  239.          }
  240.       }
  241.       else is_eof=-1;                   // No more data in the file
  242.    } while(is_eof>=0);
  243.    fclose(efp);                         // Close the password file
  244.    return(1);                           // And return (1=fastmode will be used)
  245. }
  246.  
  247. void DisplayStatus(char *word) {
  248.    float dt;
  249.  
  250.    tm2 = time(NULL);
  251.    if(!(dt=difftime(tm2, tm1))) dt=1;
  252.  
  253.    printf("v: %u  c: %lu  s: %.0f  c/s: %.0f w: %s\n",
  254.          fpwd, (unsigned long)eacct*wc, dt, (float)eacct*wc/dt,word);
  255. }
  256.  
  257. /* EXIT ROUTINE */ // A better one coming up sometime...
  258. void Back2DOS(int code, char *txt) {
  259.    char msg_xitabort[]="\n[XiT] aborted while processing the word '%s'!!!\n";
  260.    char msg_totwords[]="Total number of words processed in this session: %lu\n";
  261.    char msg_totaccts[]="Total number of accounts                       : %u\n";
  262.    char msg_totencrp[]="Total number of ecryptions made in this sesion : %lu\n";
  263.    char msg_totltime[]="Total time elapsed  : %.0f seconds\n";
  264.    char msg_encsecnd[]="Encryptions/second  : %.0f\n";
  265.    char msg_fndpswds[]="Total number of passwords found: %u\n";
  266.    float difft;
  267.    float encsc;
  268.  
  269.    tm2 = time(NULL);
  270.    difft = difftime(tm2, tm1);
  271.    encsc = (float)eacct*wc/difft;
  272.    if(code>-2) {
  273.       if((ofp=fopen(ofn,"a"))==NULL) { perror(ofn); exit(-3); }
  274.       putchar('\n');
  275.       fputc('\n',ofp);
  276.       if(code<0) {
  277.          fprintf(ofp,msg_xitabort ,txt);
  278.          printf(msg_xitabort,txt);
  279.       }
  280.       else {
  281.          putchar('\n');
  282.          fputc('\n',ofp);
  283.       }
  284.       fprintf(ofp, msg_totwords,wc);         printf(msg_totwords,wc);
  285.       fprintf(ofp, msg_totaccts,eacct);      printf(msg_totaccts,eacct);
  286.       fprintf(ofp, msg_totencrp,(unsigned long)eacct*wc);   printf(msg_totencrp,(unsigned long)eacct*wc);
  287.       fprintf(ofp, msg_totltime,difft);      printf(msg_totltime,difft);
  288.       fprintf(ofp, msg_encsecnd,encsc);      printf(msg_encsecnd,encsc);
  289.       fprintf(ofp, msg_fndpswds,fpwd);         printf(msg_fndpswds,fpwd);
  290.    }
  291.    fcloseall();
  292.    exit(code);
  293. }
  294.  
  295. void help(void) {
  296.    puts("\nUsage: XIT2 <dict_filename> <epwd_filename> <ofilename> [options]\n");
  297.    puts("<dict_filename>     : Name of the file containing words (dictionary).");
  298.    puts("<XiT/ECRY_filename> : Name of the (sorted) file containing encrypted passwords.");
  299.    puts("<ofilename>         : Output filename\n");
  300.    puts("[options]");
  301.    puts("    -Sxxxxxxxx      : First word to check in dictionary.");
  302.    puts("    -v              : Display verbose information.\n");
  303.    exit(-1);
  304. }
  305.  
  306.